﻿#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLuaBase.lua_CSFunction;
#endif

using XLua;
using System.Collections.Generic;


namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;
    public class GameplayPVEDataUnitDataWrap 
    {
        public static void __Register(RealStatePtr L)
        {
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			System.Type type = typeof(Gameplay.PVE.Data.UnitData);
			Utils.BeginObjectRegister(type, L, translator, 0, 55, 219, 215);
			
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveSummonUnit", _m_RemoveSummonUnit);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddSummonUnit", _m_AddSummonUnit);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPassiveSkillLevel", _m_GetPassiveSkillLevel);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHudPosition", _m_GetHudPosition);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHudFlyTextPosition", _m_GetHudFlyTextPosition);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPassivePriority", _m_GetPassivePriority);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitHeroConfig", _m_InitHeroConfig);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitMonsterConfig", _m_InitMonsterConfig);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateHeroBattleProperty", _m_UpdateHeroBattleProperty);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitObstacleData", _m_InitObstacleData);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateSummonAttribute", _m_CalculateSummonAttribute);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClonePropertyFromParent", _m_ClonePropertyFromParent);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTargetTeam", _m_GetTargetTeam);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddTag", _m_AddTag);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetReplaceObstacleUnit", _m_GetReplaceObstacleUnit);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "LeaveHidePoint", _m_LeaveHidePoint);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GoInHidePoint", _m_GoInHidePoint);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetOrders", _m_GetOrders);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearOrders", _m_ClearOrders);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveOrder", _m_RemoveOrder);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddOrder", _m_AddOrder);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCurrentOrderState", _m_GetCurrentOrderState);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasSpecificOrder", _m_HasSpecificOrder);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsInitiative", _m_IsInitiative);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsInStun", _m_IsInStun);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsInControl", _m_IsInControl);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "CanAutoUseSkill", _m_CanAutoUseSkill);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "CanUseSkill", _m_CanUseSkill);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsSkillInCD", _m_IsSkillInCD);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSkillBornCD", _m_GetSkillBornCD);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSkillCD", _m_GetSkillCD);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAutoSkillCD", _m_GetAutoSkillCD);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAttractAttackTarget", _m_SetAttractAttackTarget);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLockTarget", _m_SetLockTarget);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsSkillInRange", _m_IsSkillInRange);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsAttackInRange", _m_IsAttackInRange);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveLockTarget", _m_RemoveLockTarget);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIsInAttack", _m_SetIsInAttack);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIsInSkill", _m_SetIsInSkill);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIsCanMove", _m_SetIsCanMove);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIsInMainSkill", _m_SetIsInMainSkill);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsInAttack", _m_IsInAttack);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsInSkill", _m_IsInSkill);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsInMainSkill", _m_IsInMainSkill);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsCanSkill", _m_IsCanSkill);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsCanAttack", _m_IsCanAttack);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsCanMove", _m_IsCanMove);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasSkillInitiative", _m_HasSkillInitiative);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTargetPosition", _m_SetTargetPosition);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTargetForward", _m_SetTargetForward);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "SpecialElementCount", _m_SpecialElementCount);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckMpChange", _m_CheckMpChange);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsInScreen", _m_IsInScreen);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddAstar", _m_AddAstar);
			Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAstar", _m_RemoveAstar);
			
			
			Utils.RegisterFunc(L, Utils.GETTER_IDX, "battleType", _g_get_battleType);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "position", _g_get_position);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "moveState", _g_get_moveState);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "attackState", _g_get_attackState);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "manualForward", _g_get_manualForward);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "forward", _g_get_forward);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "attackPosition", _g_get_attackPosition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "positionId", _g_get_positionId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "moveSpeed", _g_get_moveSpeed);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "skillFrameSpeedChangeValue", _g_get_skillFrameSpeedChangeValue);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "weaponAttackSpeed", _g_get_weaponAttackSpeed);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "propertyAttackSpeed", _g_get_propertyAttackSpeed);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "flyTextPosition", _g_get_flyTextPosition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "flyTextCriticalPosition", _g_get_flyTextCriticalPosition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "bulletDamageRatio", _g_get_bulletDamageRatio);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Level", _g_get_Level);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Star", _g_get_Star);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "AttackValue", _g_get_AttackValue);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "DefenceValue", _g_get_DefenceValue);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "TotalHp", _g_get_TotalHp);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "CurrentHp", _g_get_CurrentHp);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "TotalMp", _g_get_TotalMp);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "CurrentMp", _g_get_CurrentMp);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "TotalShield", _g_get_TotalShield);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "CurrentShield", _g_get_CurrentShield);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "DamageBonus", _g_get_DamageBonus);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "CriticalRate", _g_get_CriticalRate);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "CriticalBonus", _g_get_CriticalBonus);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "AttackSpeedBonus", _g_get_AttackSpeedBonus);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "DamageReduce", _g_get_DamageReduce);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "CriticalReduce", _g_get_CriticalReduce);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "SuckBloodRatio", _g_get_SuckBloodRatio);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "HealBonus", _g_get_HealBonus);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "HpBonus", _g_get_HpBonus);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "AttackBonus", _g_get_AttackBonus);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "DefenceBonus", _g_get_DefenceBonus);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "NormalAttackDamageReduce", _g_get_NormalAttackDamageReduce);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "NormalAttackDamageBonus", _g_get_NormalAttackDamageBonus);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "SkillDamageReduce", _g_get_SkillDamageReduce);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "SkillDamageBonus", _g_get_SkillDamageBonus);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Thorns", _g_get_Thorns);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "invulnerable", _g_get_invulnerable);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectable", _g_get_selectable);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isDead", _g_get_isDead);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isDying", _g_get_isDying);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "searchInfos", _g_get_searchInfos);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "searchType", _g_get_searchType);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "unitType", _g_get_unitType);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "id", _g_get_id);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "stage", _g_get_stage);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "team", _g_get_team);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "index", _g_get_index);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "autoSkillPriority", _g_get_autoSkillPriority);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "autoSkillCd", _g_get_autoSkillCd);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "autoSkillBornCd", _g_get_autoSkillBornCd);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasAutoUsedSkill", _g_get_hasAutoUsedSkill);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "lockTarget", _g_get_lockTarget);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hatredTarget", _g_get_hatredTarget);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rigidRatio", _g_get_rigidRatio);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hatredDistance", _g_get_hatredDistance);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "astarPosition", _g_get_astarPosition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "moveOffset", _g_get_moveOffset);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "moveForwardOffset", _g_get_moveForwardOffset);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "moveStateChangeTime", _g_get_moveStateChangeTime);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "manualAimForward", _g_get_manualAimForward);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "damageForward", _g_get_damageForward);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "birthPosition", _g_get_birthPosition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetPosition", _g_get_targetPosition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetForward", _g_get_targetForward);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "patrolPosition", _g_get_patrolPosition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rendererOriginScale", _g_get_rendererOriginScale);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "configAttackPosition", _g_get_configAttackPosition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "attackRange", _g_get_attackRange);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "searchRange", _g_get_searchRange);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "moveSpeedRatio", _g_get_moveSpeedRatio);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isSummonUnit", _g_get_isSummonUnit);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "summonId", _g_get_summonId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "summonConfig", _g_get_summonConfig);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "summonIndex", _g_get_summonIndex);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "summonSkillIndex", _g_get_summonSkillIndex);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "summonParent", _g_get_summonParent);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "summonUnit", _g_get_summonUnit);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "killNum", _g_get_killNum);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rangeType", _g_get_rangeType);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "positionType", _g_get_positionType);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isCanSquat", _g_get_isCanSquat);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "attackSpeedRatio", _g_get_attackSpeedRatio);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetMoveSpeed", _g_get_targetMoveSpeed);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "moveSpeedAccelerate", _g_get_moveSpeedAccelerate);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "configMoveSpeed", _g_get_configMoveSpeed);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "walkSpeed", _g_get_walkSpeed);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "runSpeed", _g_get_runSpeed);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "angleSpeed", _g_get_angleSpeed);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isDraggable", _g_get_isDraggable);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "damageRatio", _g_get_damageRatio);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isLogicPause", _g_get_isLogicPause);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasBattleInSight", _g_get_hasBattleInSight);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasObstacleFront", _g_get_hasObstacleFront);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "battleInSightPosition", _g_get_battleInSightPosition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hatredDic", _g_get_hatredDic);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "skillList", _g_get_skillList);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "bornElements", _g_get_bornElements);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "considerAstar", _g_get_considerAstar);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "obstacleConfig", _g_get_obstacleConfig);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "config", _g_get_config);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "modelId", _g_get_modelId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "deadModelId", _g_get_deadModelId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "skillModelId", _g_get_skillModelId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rpgAttackRange", _g_get_rpgAttackRange);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "pveAttackRange", _g_get_pveAttackRange);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rpgSkillCost", _g_get_rpgSkillCost);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "shootTurns", _g_get_shootTurns);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "ammoCount", _g_get_ammoCount);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "shootInterval", _g_get_shootInterval);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "fixedShootInterval", _g_get_fixedShootInterval);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rpgNormalAttackId", _g_get_rpgNormalAttackId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rpgNormalSquatAttackId", _g_get_rpgNormalSquatAttackId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rpgMoveAttackId", _g_get_rpgMoveAttackId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rpgSkillId", _g_get_rpgSkillId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rpgSkillInitiativeLevel", _g_get_rpgSkillInitiativeLevel);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rpgPassiveSkillIds", _g_get_rpgPassiveSkillIds);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rpgPassiveSkillPriority", _g_get_rpgPassiveSkillPriority);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "weaponType", _g_get_weaponType);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "walkSpeedRatio", _g_get_walkSpeedRatio);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "runSpeedRatio", _g_get_runSpeedRatio);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "searchTypeRpg", _g_get_searchTypeRpg);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "searchTypePve", _g_get_searchTypePve);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "searchSort", _g_get_searchSort);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "searchChangeType", _g_get_searchChangeType);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "reloadTime", _g_get_reloadTime);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "moveType", _g_get_moveType);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rpgNormalAttackSkillConfig", _g_get_rpgNormalAttackSkillConfig);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rpgInitiativeSkillConfig", _g_get_rpgInitiativeSkillConfig);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rpgMoveAttackSkillConfig", _g_get_rpgMoveAttackSkillConfig);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "enemyStage", _g_get_enemyStage);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "enemyIndex", _g_get_enemyIndex);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "colliderSize", _g_get_colliderSize);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "colliderCenter", _g_get_colliderCenter);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "skillCd", _g_get_skillCd);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "lastSkillTime", _g_get_lastSkillTime);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "bornTime", _g_get_bornTime);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "followOffset", _g_get_followOffset);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "followOffsetDistance", _g_get_followOffsetDistance);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "followOffsetDistanceSqr", _g_get_followOffsetDistanceSqr);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "followTarget", _g_get_followTarget);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasTriggerdSpecialCase", _g_get_hasTriggerdSpecialCase);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isInSpecialCase", _g_get_isInSpecialCase);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hitPoints", _g_get_hitPoints);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "gunPoints", _g_get_gunPoints);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "bulletCasePoints", _g_get_bulletCasePoints);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "skillEffectPoints", _g_get_skillEffectPoints);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "buffEffectPoints", _g_get_buffEffectPoints);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "flyTextPoint", _g_get_flyTextPoint);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "flyTextCriticalPoint", _g_get_flyTextCriticalPoint);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "flyTextRange", _g_get_flyTextRange);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hudPoint", _g_get_hudPoint);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hudHeight", _g_get_hudHeight);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isInBirthPosition", _g_get_isInBirthPosition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasInitedRpg", _g_get_hasInitedRpg);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "leftAmmoCount", _g_get_leftAmmoCount);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "totalAmmoCount", _g_get_totalAmmoCount);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isReloading", _g_get_isReloading);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hidePositions", _g_get_hidePositions);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hidingUnit", _g_get_hidingUnit);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "readyTohideObstacle", _g_get_readyTohideObstacle);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hidingObstacle", _g_get_hidingObstacle);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hidePosition", _g_get_hidePosition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isInStageAttackPosition", _g_get_isInStageAttackPosition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "stageAttackPosition", _g_get_stageAttackPosition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isBoss", _g_get_isBoss);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isElite", _g_get_isElite);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "canShowBossWarning", _g_get_canShowBossWarning);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isShowingSpawn", _g_get_isShowingSpawn);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isGoingToHidePoint", _g_get_isGoingToHidePoint);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isManualMoving", _g_get_isManualMoving);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "needNextShoot", _g_get_needNextShoot);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isMoveAttacking", _g_get_isMoveAttacking);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "ignoreAmmoLimit", _g_get_ignoreAmmoLimit);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isApplyAnimationMovement", _g_get_isApplyAnimationMovement);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isDisarm", _g_get_isDisarm);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isSilent", _g_get_isSilent);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isInAction", _g_get_isInAction);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "battleUnit", _g_get_battleUnit);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetHidingPoint", _g_get_targetHidingPoint);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "accuracy", _g_get_accuracy);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "evade", _g_get_evade);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "bulletForward", _g_get_bulletForward);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "aimTransform", _g_get_aimTransform);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "aimTransformIndex", _g_get_aimTransformIndex);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasJoinBattle", _g_get_hasJoinBattle);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isCanMoveAttack", _g_get_isCanMoveAttack);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "switchWeaponId", _g_get_switchWeaponId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "roadType", _g_get_roadType);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "lifeTime", _g_get_lifeTime);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "heroId", _g_get_heroId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "monsterID", _g_get_monsterID);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasShowBossWarning", _g_get_hasShowBossWarning);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "monsterConfig", _g_get_monsterConfig);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "attackSequenceSkills", _g_get_attackSequenceSkills);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "specialBuffs", _g_get_specialBuffs);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "normalAttackTimeEachTurn", _g_get_normalAttackTimeEachTurn);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "mpCost", _g_get_mpCost);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "GenderDamageBonus", _g_get_GenderDamageBonus);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "GenderDamageReduce", _g_get_GenderDamageReduce);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Gender", _g_get_Gender);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "controlable", _g_get_controlable);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "invulnerableList", _g_get_invulnerableList);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "blockList", _g_get_blockList);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "tagList", _g_get_tagList);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "initAttack", _g_get_initAttack);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "initDefence", _g_get_initDefence);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "initMp", _g_get_initMp);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isHiding", _g_get_isHiding);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "controlType", _g_get_controlType);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "attractAttackTarget", _g_get_attractAttackTarget);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasReachAttackPosition", _g_get_hasReachAttackPosition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isCanAttackByFindPath", _g_get_isCanAttackByFindPath);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isSelfMeleeAtRegion", _g_get_isSelfMeleeAtRegion);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "firstTimeShowInScreen", _g_get_firstTimeShowInScreen);
            
			Utils.RegisterFunc(L, Utils.SETTER_IDX, "position", _s_set_position);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "moveState", _s_set_moveState);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "attackState", _s_set_attackState);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "manualForward", _s_set_manualForward);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "forward", _s_set_forward);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "attackPosition", _s_set_attackPosition);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "positionId", _s_set_positionId);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "moveSpeed", _s_set_moveSpeed);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "skillFrameSpeedChangeValue", _s_set_skillFrameSpeedChangeValue);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "weaponAttackSpeed", _s_set_weaponAttackSpeed);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "propertyAttackSpeed", _s_set_propertyAttackSpeed);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "bulletDamageRatio", _s_set_bulletDamageRatio);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "Level", _s_set_Level);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "Star", _s_set_Star);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "AttackValue", _s_set_AttackValue);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "DefenceValue", _s_set_DefenceValue);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "TotalHp", _s_set_TotalHp);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "CurrentHp", _s_set_CurrentHp);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "TotalMp", _s_set_TotalMp);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "CurrentMp", _s_set_CurrentMp);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "TotalShield", _s_set_TotalShield);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "CurrentShield", _s_set_CurrentShield);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "DamageBonus", _s_set_DamageBonus);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "CriticalRate", _s_set_CriticalRate);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "CriticalBonus", _s_set_CriticalBonus);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "AttackSpeedBonus", _s_set_AttackSpeedBonus);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "DamageReduce", _s_set_DamageReduce);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "CriticalReduce", _s_set_CriticalReduce);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "SuckBloodRatio", _s_set_SuckBloodRatio);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "HealBonus", _s_set_HealBonus);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "HpBonus", _s_set_HpBonus);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "AttackBonus", _s_set_AttackBonus);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "DefenceBonus", _s_set_DefenceBonus);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "NormalAttackDamageReduce", _s_set_NormalAttackDamageReduce);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "NormalAttackDamageBonus", _s_set_NormalAttackDamageBonus);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "SkillDamageReduce", _s_set_SkillDamageReduce);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "SkillDamageBonus", _s_set_SkillDamageBonus);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "Thorns", _s_set_Thorns);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectable", _s_set_selectable);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isDead", _s_set_isDead);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isDying", _s_set_isDying);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "searchInfos", _s_set_searchInfos);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "searchType", _s_set_searchType);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "unitType", _s_set_unitType);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "id", _s_set_id);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "stage", _s_set_stage);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "team", _s_set_team);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "index", _s_set_index);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "autoSkillPriority", _s_set_autoSkillPriority);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "autoSkillCd", _s_set_autoSkillCd);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "autoSkillBornCd", _s_set_autoSkillBornCd);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hasAutoUsedSkill", _s_set_hasAutoUsedSkill);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "lockTarget", _s_set_lockTarget);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hatredTarget", _s_set_hatredTarget);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "rigidRatio", _s_set_rigidRatio);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hatredDistance", _s_set_hatredDistance);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "astarPosition", _s_set_astarPosition);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "moveOffset", _s_set_moveOffset);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "moveForwardOffset", _s_set_moveForwardOffset);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "moveStateChangeTime", _s_set_moveStateChangeTime);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "manualAimForward", _s_set_manualAimForward);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "damageForward", _s_set_damageForward);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "birthPosition", _s_set_birthPosition);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "targetPosition", _s_set_targetPosition);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "targetForward", _s_set_targetForward);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "patrolPosition", _s_set_patrolPosition);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "rendererOriginScale", _s_set_rendererOriginScale);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "configAttackPosition", _s_set_configAttackPosition);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "attackRange", _s_set_attackRange);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "searchRange", _s_set_searchRange);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "moveSpeedRatio", _s_set_moveSpeedRatio);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isSummonUnit", _s_set_isSummonUnit);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "summonId", _s_set_summonId);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "summonConfig", _s_set_summonConfig);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "summonIndex", _s_set_summonIndex);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "summonSkillIndex", _s_set_summonSkillIndex);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "summonParent", _s_set_summonParent);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "summonUnit", _s_set_summonUnit);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "killNum", _s_set_killNum);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "rangeType", _s_set_rangeType);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "positionType", _s_set_positionType);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isCanSquat", _s_set_isCanSquat);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "attackSpeedRatio", _s_set_attackSpeedRatio);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "targetMoveSpeed", _s_set_targetMoveSpeed);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "moveSpeedAccelerate", _s_set_moveSpeedAccelerate);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "configMoveSpeed", _s_set_configMoveSpeed);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "walkSpeed", _s_set_walkSpeed);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "runSpeed", _s_set_runSpeed);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "angleSpeed", _s_set_angleSpeed);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isDraggable", _s_set_isDraggable);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "damageRatio", _s_set_damageRatio);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isLogicPause", _s_set_isLogicPause);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hasBattleInSight", _s_set_hasBattleInSight);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hasObstacleFront", _s_set_hasObstacleFront);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "battleInSightPosition", _s_set_battleInSightPosition);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hatredDic", _s_set_hatredDic);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "skillList", _s_set_skillList);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "bornElements", _s_set_bornElements);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "considerAstar", _s_set_considerAstar);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "obstacleConfig", _s_set_obstacleConfig);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "config", _s_set_config);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "modelId", _s_set_modelId);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "deadModelId", _s_set_deadModelId);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "skillModelId", _s_set_skillModelId);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "rpgAttackRange", _s_set_rpgAttackRange);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "pveAttackRange", _s_set_pveAttackRange);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "rpgSkillCost", _s_set_rpgSkillCost);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "shootTurns", _s_set_shootTurns);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "ammoCount", _s_set_ammoCount);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "shootInterval", _s_set_shootInterval);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "fixedShootInterval", _s_set_fixedShootInterval);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "rpgNormalAttackId", _s_set_rpgNormalAttackId);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "rpgNormalSquatAttackId", _s_set_rpgNormalSquatAttackId);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "rpgMoveAttackId", _s_set_rpgMoveAttackId);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "rpgSkillId", _s_set_rpgSkillId);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "rpgSkillInitiativeLevel", _s_set_rpgSkillInitiativeLevel);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "rpgPassiveSkillIds", _s_set_rpgPassiveSkillIds);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "rpgPassiveSkillPriority", _s_set_rpgPassiveSkillPriority);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "weaponType", _s_set_weaponType);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "walkSpeedRatio", _s_set_walkSpeedRatio);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "runSpeedRatio", _s_set_runSpeedRatio);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "searchTypeRpg", _s_set_searchTypeRpg);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "searchTypePve", _s_set_searchTypePve);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "searchSort", _s_set_searchSort);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "searchChangeType", _s_set_searchChangeType);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "reloadTime", _s_set_reloadTime);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "moveType", _s_set_moveType);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "rpgNormalAttackSkillConfig", _s_set_rpgNormalAttackSkillConfig);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "rpgInitiativeSkillConfig", _s_set_rpgInitiativeSkillConfig);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "rpgMoveAttackSkillConfig", _s_set_rpgMoveAttackSkillConfig);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "enemyStage", _s_set_enemyStage);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "enemyIndex", _s_set_enemyIndex);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "colliderSize", _s_set_colliderSize);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "colliderCenter", _s_set_colliderCenter);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "skillCd", _s_set_skillCd);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "lastSkillTime", _s_set_lastSkillTime);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "bornTime", _s_set_bornTime);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "followOffset", _s_set_followOffset);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "followOffsetDistance", _s_set_followOffsetDistance);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "followOffsetDistanceSqr", _s_set_followOffsetDistanceSqr);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "followTarget", _s_set_followTarget);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hasTriggerdSpecialCase", _s_set_hasTriggerdSpecialCase);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isInSpecialCase", _s_set_isInSpecialCase);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hitPoints", _s_set_hitPoints);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "gunPoints", _s_set_gunPoints);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "bulletCasePoints", _s_set_bulletCasePoints);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "skillEffectPoints", _s_set_skillEffectPoints);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "buffEffectPoints", _s_set_buffEffectPoints);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "flyTextPoint", _s_set_flyTextPoint);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "flyTextCriticalPoint", _s_set_flyTextCriticalPoint);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "flyTextRange", _s_set_flyTextRange);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hudPoint", _s_set_hudPoint);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hudHeight", _s_set_hudHeight);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isInBirthPosition", _s_set_isInBirthPosition);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hasInitedRpg", _s_set_hasInitedRpg);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "leftAmmoCount", _s_set_leftAmmoCount);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "totalAmmoCount", _s_set_totalAmmoCount);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isReloading", _s_set_isReloading);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hidePositions", _s_set_hidePositions);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hidingUnit", _s_set_hidingUnit);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "readyTohideObstacle", _s_set_readyTohideObstacle);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hidingObstacle", _s_set_hidingObstacle);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hidePosition", _s_set_hidePosition);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isInStageAttackPosition", _s_set_isInStageAttackPosition);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "stageAttackPosition", _s_set_stageAttackPosition);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isBoss", _s_set_isBoss);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isElite", _s_set_isElite);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "canShowBossWarning", _s_set_canShowBossWarning);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isShowingSpawn", _s_set_isShowingSpawn);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isGoingToHidePoint", _s_set_isGoingToHidePoint);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isManualMoving", _s_set_isManualMoving);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "needNextShoot", _s_set_needNextShoot);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isMoveAttacking", _s_set_isMoveAttacking);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "ignoreAmmoLimit", _s_set_ignoreAmmoLimit);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isApplyAnimationMovement", _s_set_isApplyAnimationMovement);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isDisarm", _s_set_isDisarm);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isSilent", _s_set_isSilent);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isInAction", _s_set_isInAction);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "battleUnit", _s_set_battleUnit);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "targetHidingPoint", _s_set_targetHidingPoint);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "accuracy", _s_set_accuracy);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "evade", _s_set_evade);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "bulletForward", _s_set_bulletForward);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "aimTransform", _s_set_aimTransform);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "aimTransformIndex", _s_set_aimTransformIndex);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hasJoinBattle", _s_set_hasJoinBattle);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isCanMoveAttack", _s_set_isCanMoveAttack);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "switchWeaponId", _s_set_switchWeaponId);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "roadType", _s_set_roadType);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "lifeTime", _s_set_lifeTime);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "heroId", _s_set_heroId);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "monsterID", _s_set_monsterID);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hasShowBossWarning", _s_set_hasShowBossWarning);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "monsterConfig", _s_set_monsterConfig);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "attackSequenceSkills", _s_set_attackSequenceSkills);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "specialBuffs", _s_set_specialBuffs);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "normalAttackTimeEachTurn", _s_set_normalAttackTimeEachTurn);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "mpCost", _s_set_mpCost);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "GenderDamageBonus", _s_set_GenderDamageBonus);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "GenderDamageReduce", _s_set_GenderDamageReduce);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "Gender", _s_set_Gender);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "controlable", _s_set_controlable);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "invulnerableList", _s_set_invulnerableList);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "blockList", _s_set_blockList);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "tagList", _s_set_tagList);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "initAttack", _s_set_initAttack);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "initDefence", _s_set_initDefence);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "initMp", _s_set_initMp);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isHiding", _s_set_isHiding);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "controlType", _s_set_controlType);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "attractAttackTarget", _s_set_attractAttackTarget);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "hasReachAttackPosition", _s_set_hasReachAttackPosition);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isCanAttackByFindPath", _s_set_isCanAttackByFindPath);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isSelfMeleeAtRegion", _s_set_isSelfMeleeAtRegion);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "firstTimeShowInScreen", _s_set_firstTimeShowInScreen);
            
			
			Utils.EndObjectRegister(type, L, translator, null, null,
			    null, null, null);

		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
			
			
            
			
			
			
            Utils.RegisterFunc(L, Utils.CLS_IDX, "New", __CreateInstanceNew);
			Utils.EndClassRegister(type, L, translator);
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstance(RealStatePtr L)
        {
            
			try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
				if(LuaAPI.lua_gettop(L) == 1)
				{
					
					var gen_ret = new Gameplay.PVE.Data.UnitData();
					translator.Push(L, gen_ret);
                    
					return 1;
				}
				
			}
			catch(System.Exception gen_e) {
				return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
			}
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.Data.UnitData constructor!");
            
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstanceNew(RealStatePtr L)
        {
            
			try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
				if(LuaAPI.lua_gettop(L) == 0)
				{
					
					var gen_ret = new Gameplay.PVE.Data.UnitData();
					translator.Push(L, gen_ret);
                    
					return 1;
				}
				
			}
			catch(System.Exception gen_e) {
				return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
			}
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.Data.UnitData constructor!");
            
        }

        
		
        
		
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RemoveSummonUnit(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _unitId = LuaAPI.xlua_tointeger(L, 2);
                    int _summonId = LuaAPI.xlua_tointeger(L, 3);
                    
                    gen_to_be_invoked.RemoveSummonUnit( _unitId, _summonId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddSummonUnit(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _unitId = LuaAPI.xlua_tointeger(L, 2);
                    int _summonId = LuaAPI.xlua_tointeger(L, 3);
                    
                    gen_to_be_invoked.AddSummonUnit( _unitId, _summonId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetPassiveSkillLevel(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _id = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = gen_to_be_invoked.GetPassiveSkillLevel( _id );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetHudPosition(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetHudPosition(  );
                        translator.PushUnityEngineVector3(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetHudFlyTextPosition(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetHudFlyTextPosition(  );
                        translator.PushUnityEngineVector3(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetPassivePriority(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _skillId = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = gen_to_be_invoked.GetPassivePriority( _skillId );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_InitHeroConfig(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _heroId = LuaAPI.xlua_tointeger(L, 2);
                    
                    gen_to_be_invoked.InitHeroConfig( _heroId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_InitMonsterConfig(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) 
                {
                    int _monsterId = LuaAPI.xlua_tointeger(L, 2);
                    int _level = LuaAPI.xlua_tointeger(L, 3);
                    
                    gen_to_be_invoked.InitMonsterConfig( _monsterId, _level );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) 
                {
                    int _monsterId = LuaAPI.xlua_tointeger(L, 2);
                    
                    gen_to_be_invoked.InitMonsterConfig( _monsterId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.Data.UnitData.InitMonsterConfig!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateHeroBattleProperty(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.UpdateHeroBattleProperty(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_InitObstacleData(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.InitObstacleData(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CalculateSummonAttribute(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    Gameplay.PVE.Data.UnitData _parent = (Gameplay.PVE.Data.UnitData)translator.GetObject(L, 2, typeof(Gameplay.PVE.Data.UnitData));
                    int _skillLevel = LuaAPI.xlua_tointeger(L, 3);
                    
                    gen_to_be_invoked.CalculateSummonAttribute( _parent, _skillLevel );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ClonePropertyFromParent(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 3&& translator.Assignable<Gameplay.PVE.Data.UnitData>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) 
                {
                    Gameplay.PVE.Data.UnitData _parent = (Gameplay.PVE.Data.UnitData)translator.GetObject(L, 2, typeof(Gameplay.PVE.Data.UnitData));
                    float _ratio = (float)LuaAPI.lua_tonumber(L, 3);
                    
                    gen_to_be_invoked.ClonePropertyFromParent( _parent, _ratio );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 2&& translator.Assignable<Gameplay.PVE.Data.UnitData>(L, 2)) 
                {
                    Gameplay.PVE.Data.UnitData _parent = (Gameplay.PVE.Data.UnitData)translator.GetObject(L, 2, typeof(Gameplay.PVE.Data.UnitData));
                    
                    gen_to_be_invoked.ClonePropertyFromParent( _parent );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.Data.UnitData.ClonePropertyFromParent!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetTargetTeam(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _searchType = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = gen_to_be_invoked.GetTargetTeam( _searchType );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddTag(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) 
                {
                    int _tag = LuaAPI.xlua_tointeger(L, 2);
                    int _tagValue = LuaAPI.xlua_tointeger(L, 3);
                    
                    gen_to_be_invoked.AddTag( _tag, _tagValue );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) 
                {
                    int _tag = LuaAPI.xlua_tointeger(L, 2);
                    
                    gen_to_be_invoked.AddTag( _tag );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.Data.UnitData.AddTag!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetReplaceObstacleUnit(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetReplaceObstacleUnit(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LeaveHidePoint(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.LeaveHidePoint(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GoInHidePoint(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.GoInHidePoint(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetOrders(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetOrders(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ClearOrders(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.ClearOrders(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RemoveOrder(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    Gameplay.PVE.UnitOrder _order = (Gameplay.PVE.UnitOrder)translator.GetObject(L, 2, typeof(Gameplay.PVE.UnitOrder));
                    
                    gen_to_be_invoked.RemoveOrder( _order );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddOrder(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 3&& translator.Assignable<Gameplay.PVE.UnitOrder>(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) 
                {
                    Gameplay.PVE.UnitOrder _order = (Gameplay.PVE.UnitOrder)translator.GetObject(L, 2, typeof(Gameplay.PVE.UnitOrder));
                    bool _isFront = LuaAPI.lua_toboolean(L, 3);
                    
                    gen_to_be_invoked.AddOrder( _order, _isFront );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 2&& translator.Assignable<Gameplay.PVE.UnitOrder>(L, 2)) 
                {
                    Gameplay.PVE.UnitOrder _order = (Gameplay.PVE.UnitOrder)translator.GetObject(L, 2, typeof(Gameplay.PVE.UnitOrder));
                    
                    gen_to_be_invoked.AddOrder( _order );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.Data.UnitData.AddOrder!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetCurrentOrderState(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetCurrentOrderState(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_HasSpecificOrder(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.HasSpecificOrder(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsInitiative(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsInitiative(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsInStun(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsInStun(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsInControl(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsInControl(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CanAutoUseSkill(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.CanAutoUseSkill(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CanUseSkill(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.CanUseSkill(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsSkillInCD(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsSkillInCD(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetSkillBornCD(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetSkillBornCD(  );
                        LuaAPI.lua_pushnumber(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetSkillCD(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetSkillCD(  );
                        LuaAPI.lua_pushnumber(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetAutoSkillCD(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.GetAutoSkillCD(  );
                        LuaAPI.lua_pushnumber(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetAttractAttackTarget(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    Gameplay.PVE.Entity.UnitBase _target = (Gameplay.PVE.Entity.UnitBase)translator.GetObject(L, 2, typeof(Gameplay.PVE.Entity.UnitBase));
                    
                    gen_to_be_invoked.SetAttractAttackTarget( _target );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetLockTarget(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    Gameplay.PVE.Entity.UnitBase _target = (Gameplay.PVE.Entity.UnitBase)translator.GetObject(L, 2, typeof(Gameplay.PVE.Entity.UnitBase));
                    
                    gen_to_be_invoked.SetLockTarget( _target );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsSkillInRange(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsSkillInRange(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsAttackInRange(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) 
                {
                    float _rangeFloat = (float)LuaAPI.lua_tonumber(L, 2);
                    
                        var gen_ret = gen_to_be_invoked.IsAttackInRange( _rangeFloat );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 1) 
                {
                    
                        var gen_ret = gen_to_be_invoked.IsAttackInRange(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.Data.UnitData.IsAttackInRange!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RemoveLockTarget(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.RemoveLockTarget(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetIsInAttack(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _value = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.SetIsInAttack( _value );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetIsInSkill(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _value = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.SetIsInSkill( _value );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetIsCanMove(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _value = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.SetIsCanMove( _value );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetIsInMainSkill(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _value = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.SetIsInMainSkill( _value );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsInAttack(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsInAttack(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsInSkill(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsInSkill(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsInMainSkill(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsInMainSkill(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsCanSkill(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsCanSkill(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsCanAttack(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsCanAttack(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsCanMove(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsCanMove(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_HasSkillInitiative(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.HasSkillInitiative(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetTargetPosition(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    UnityEngine.Vector3 _position;translator.Get(L, 2, out _position);
                    
                    gen_to_be_invoked.SetTargetPosition( _position );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetTargetForward(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    UnityEngine.Vector3 _forward;translator.Get(L, 2, out _forward);
                    
                    gen_to_be_invoked.SetTargetForward( _forward );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SpecialElementCount(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _type = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = gen_to_be_invoked.SpecialElementCount( _type );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CheckMpChange(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 4&& translator.Assignable<Gameplay.PVE.ERecoverMpType>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) 
                {
                    Gameplay.PVE.ERecoverMpType _type;translator.Get(L, 2, out _type);
                    int _slice = LuaAPI.xlua_tointeger(L, 3);
                    float _ratio = (float)LuaAPI.lua_tonumber(L, 4);
                    
                        var gen_ret = gen_to_be_invoked.CheckMpChange( _type, _slice, _ratio );
                        LuaAPI.lua_pushnumber(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 3&& translator.Assignable<Gameplay.PVE.ERecoverMpType>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) 
                {
                    Gameplay.PVE.ERecoverMpType _type;translator.Get(L, 2, out _type);
                    int _slice = LuaAPI.xlua_tointeger(L, 3);
                    
                        var gen_ret = gen_to_be_invoked.CheckMpChange( _type, _slice );
                        LuaAPI.lua_pushnumber(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 2&& translator.Assignable<Gameplay.PVE.ERecoverMpType>(L, 2)) 
                {
                    Gameplay.PVE.ERecoverMpType _type;translator.Get(L, 2, out _type);
                    
                        var gen_ret = gen_to_be_invoked.CheckMpChange( _type );
                        LuaAPI.lua_pushnumber(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to Gameplay.PVE.Data.UnitData.CheckMpChange!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsInScreen(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        var gen_ret = gen_to_be_invoked.IsInScreen(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddAstar(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.AddAstar(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RemoveAstar(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.RemoveAstar(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_battleType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.battleType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_position(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.position);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_moveState(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.moveState);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_attackState(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.attackState);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_manualForward(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.manualForward);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_forward(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.forward);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_attackPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.attackPosition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_positionId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.positionId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_moveSpeed(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.moveSpeed);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_skillFrameSpeedChangeValue(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.skillFrameSpeedChangeValue);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_weaponAttackSpeed(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.weaponAttackSpeed);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_propertyAttackSpeed(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.propertyAttackSpeed);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_flyTextPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.flyTextPosition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_flyTextCriticalPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.flyTextCriticalPosition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_bulletDamageRatio(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.bulletDamageRatio);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_Level(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Level);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_Star(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Star);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_AttackValue(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.AttackValue);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_DefenceValue(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.DefenceValue);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_TotalHp(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.TotalHp);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_CurrentHp(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.CurrentHp);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_TotalMp(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.TotalMp);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_CurrentMp(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.CurrentMp);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_TotalShield(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.TotalShield);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_CurrentShield(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.CurrentShield);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_DamageBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.DamageBonus);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_CriticalRate(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.CriticalRate);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_CriticalBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.CriticalBonus);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_AttackSpeedBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.AttackSpeedBonus);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_DamageReduce(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.DamageReduce);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_CriticalReduce(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.CriticalReduce);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_SuckBloodRatio(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.SuckBloodRatio);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_HealBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.HealBonus);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_HpBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.HpBonus);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_AttackBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.AttackBonus);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_DefenceBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.DefenceBonus);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_NormalAttackDamageReduce(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.NormalAttackDamageReduce);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_NormalAttackDamageBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.NormalAttackDamageBonus);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_SkillDamageReduce(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.SkillDamageReduce);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_SkillDamageBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.SkillDamageBonus);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_Thorns(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Thorns);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_invulnerable(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.invulnerable);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_selectable(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.selectable);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isDead(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isDead);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isDying(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isDying);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_searchInfos(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.searchInfos);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_searchType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.searchType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_unitType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.unitType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_id(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.id);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_stage(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.stage);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_team(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.team);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_index(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.index);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_autoSkillPriority(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.autoSkillPriority);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_autoSkillCd(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.autoSkillCd);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_autoSkillBornCd(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.autoSkillBornCd);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hasAutoUsedSkill(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasAutoUsedSkill);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_lockTarget(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.lockTarget);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hatredTarget(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.hatredTarget);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_rigidRatio(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.rigidRatio);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hatredDistance(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.hatredDistance);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_astarPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.astarPosition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_moveOffset(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.moveOffset);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_moveForwardOffset(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.moveForwardOffset);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_moveStateChangeTime(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.moveStateChangeTime);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_manualAimForward(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.manualAimForward);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_damageForward(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.damageForward);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_birthPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.birthPosition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_targetPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.targetPosition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_targetForward(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.targetForward);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_patrolPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.patrolPosition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_rendererOriginScale(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.rendererOriginScale);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_configAttackPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.configAttackPosition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_attackRange(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.attackRange);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_searchRange(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.searchRange);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_moveSpeedRatio(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.moveSpeedRatio);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isSummonUnit(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isSummonUnit);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_summonId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.summonId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_summonConfig(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.summonConfig);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_summonIndex(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.summonIndex);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_summonSkillIndex(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.summonSkillIndex);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_summonParent(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.summonParent);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_summonUnit(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.summonUnit);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_killNum(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.killNum);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_rangeType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.rangeType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_positionType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.positionType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isCanSquat(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isCanSquat);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_attackSpeedRatio(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.attackSpeedRatio);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_targetMoveSpeed(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.targetMoveSpeed);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_moveSpeedAccelerate(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.moveSpeedAccelerate);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_configMoveSpeed(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.configMoveSpeed);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_walkSpeed(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.walkSpeed);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_runSpeed(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.runSpeed);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_angleSpeed(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.angleSpeed);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isDraggable(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isDraggable);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_damageRatio(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.damageRatio);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isLogicPause(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isLogicPause);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hasBattleInSight(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasBattleInSight);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hasObstacleFront(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasObstacleFront);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_battleInSightPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.battleInSightPosition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hatredDic(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.hatredDic);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_skillList(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.skillList);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_bornElements(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.bornElements);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_considerAstar(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.considerAstar);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_obstacleConfig(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.obstacleConfig);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_config(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.config);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_modelId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.modelId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_deadModelId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.deadModelId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_skillModelId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.skillModelId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_rpgAttackRange(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.rpgAttackRange);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_pveAttackRange(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.pveAttackRange);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_rpgSkillCost(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.rpgSkillCost);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_shootTurns(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.shootTurns);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_ammoCount(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.ammoCount);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_shootInterval(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.shootInterval);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_fixedShootInterval(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.fixedShootInterval);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_rpgNormalAttackId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.rpgNormalAttackId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_rpgNormalSquatAttackId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.rpgNormalSquatAttackId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_rpgMoveAttackId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.rpgMoveAttackId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_rpgSkillId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.rpgSkillId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_rpgSkillInitiativeLevel(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.rpgSkillInitiativeLevel);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_rpgPassiveSkillIds(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.rpgPassiveSkillIds);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_rpgPassiveSkillPriority(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.rpgPassiveSkillPriority);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_weaponType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.weaponType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_walkSpeedRatio(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.walkSpeedRatio);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_runSpeedRatio(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.runSpeedRatio);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_searchTypeRpg(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.searchTypeRpg);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_searchTypePve(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.searchTypePve);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_searchSort(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.searchSort);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_searchChangeType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.searchChangeType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_reloadTime(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.reloadTime);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_moveType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.moveType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_rpgNormalAttackSkillConfig(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.rpgNormalAttackSkillConfig);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_rpgInitiativeSkillConfig(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.rpgInitiativeSkillConfig);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_rpgMoveAttackSkillConfig(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.rpgMoveAttackSkillConfig);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_enemyStage(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.enemyStage);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_enemyIndex(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.enemyIndex);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_colliderSize(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.colliderSize);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_colliderCenter(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.colliderCenter);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_skillCd(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.skillCd);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_lastSkillTime(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.lastSkillTime);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_bornTime(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.bornTime);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_followOffset(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.followOffset);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_followOffsetDistance(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.followOffsetDistance);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_followOffsetDistanceSqr(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.followOffsetDistanceSqr);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_followTarget(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.followTarget);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hasTriggerdSpecialCase(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasTriggerdSpecialCase);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isInSpecialCase(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isInSpecialCase);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hitPoints(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.hitPoints);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_gunPoints(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.gunPoints);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_bulletCasePoints(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.bulletCasePoints);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_skillEffectPoints(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.skillEffectPoints);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_buffEffectPoints(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.buffEffectPoints);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_flyTextPoint(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.flyTextPoint);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_flyTextCriticalPoint(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.flyTextCriticalPoint);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_flyTextRange(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector2(L, gen_to_be_invoked.flyTextRange);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hudPoint(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.hudPoint);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hudHeight(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.hudHeight);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isInBirthPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isInBirthPosition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hasInitedRpg(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasInitedRpg);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_leftAmmoCount(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.leftAmmoCount);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_totalAmmoCount(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.totalAmmoCount);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isReloading(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isReloading);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hidePositions(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.hidePositions);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hidingUnit(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.hidingUnit);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_readyTohideObstacle(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.readyTohideObstacle);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hidingObstacle(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.hidingObstacle);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hidePosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.hidePosition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isInStageAttackPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isInStageAttackPosition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_stageAttackPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.stageAttackPosition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isBoss(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isBoss);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isElite(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isElite);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_canShowBossWarning(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.canShowBossWarning);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isShowingSpawn(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isShowingSpawn);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isGoingToHidePoint(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isGoingToHidePoint);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isManualMoving(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isManualMoving);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_needNextShoot(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.needNextShoot);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isMoveAttacking(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isMoveAttacking);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_ignoreAmmoLimit(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.ignoreAmmoLimit);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isApplyAnimationMovement(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isApplyAnimationMovement);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isDisarm(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isDisarm);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isSilent(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isSilent);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isInAction(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isInAction);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_battleUnit(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.battleUnit);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_targetHidingPoint(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.targetHidingPoint);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_accuracy(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.accuracy);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_evade(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.evade);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_bulletForward(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.PushUnityEngineVector3(L, gen_to_be_invoked.bulletForward);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_aimTransform(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.aimTransform);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_aimTransformIndex(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.aimTransformIndex);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hasJoinBattle(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasJoinBattle);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isCanMoveAttack(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isCanMoveAttack);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_switchWeaponId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.switchWeaponId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_roadType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.roadType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_lifeTime(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.lifeTime);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_heroId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.heroId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_monsterID(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.monsterID);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hasShowBossWarning(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasShowBossWarning);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_monsterConfig(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.monsterConfig);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_attackSequenceSkills(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.attackSequenceSkills);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_specialBuffs(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.specialBuffs);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_normalAttackTimeEachTurn(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.normalAttackTimeEachTurn);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_mpCost(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.mpCost);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_GenderDamageBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.GenderDamageBonus);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_GenderDamageReduce(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.GenderDamageReduce);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_Gender(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Gender);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_controlable(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.controlable);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_invulnerableList(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.invulnerableList);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_blockList(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.blockList);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_tagList(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.tagList);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_initAttack(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.initAttack);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_initDefence(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.initDefence);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_initMp(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.initMp);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isHiding(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isHiding);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_controlType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.controlType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_attractAttackTarget(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.attractAttackTarget);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_hasReachAttackPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasReachAttackPosition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isCanAttackByFindPath(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isCanAttackByFindPath);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isSelfMeleeAtRegion(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isSelfMeleeAtRegion);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_firstTimeShowInScreen(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.firstTimeShowInScreen);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_position(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.position = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_moveState(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.moveState = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_attackState(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.attackState = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_manualForward(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.manualForward = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_forward(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.forward = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_attackPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.attackPosition = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_positionId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.positionId = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_moveSpeed(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.moveSpeed = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_skillFrameSpeedChangeValue(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.skillFrameSpeedChangeValue = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_weaponAttackSpeed(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.weaponAttackSpeed = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_propertyAttackSpeed(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.propertyAttackSpeed = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_bulletDamageRatio(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.bulletDamageRatio = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_Level(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.Level = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_Star(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.Star = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_AttackValue(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.AttackValue = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_DefenceValue(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.DefenceValue = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_TotalHp(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.TotalHp = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_CurrentHp(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.CurrentHp = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_TotalMp(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.TotalMp = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_CurrentMp(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.CurrentMp = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_TotalShield(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.TotalShield = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_CurrentShield(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.CurrentShield = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_DamageBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.DamageBonus = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_CriticalRate(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.CriticalRate = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_CriticalBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.CriticalBonus = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_AttackSpeedBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.AttackSpeedBonus = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_DamageReduce(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.DamageReduce = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_CriticalReduce(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.CriticalReduce = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_SuckBloodRatio(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.SuckBloodRatio = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_HealBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.HealBonus = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_HpBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.HpBonus = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_AttackBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.AttackBonus = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_DefenceBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.DefenceBonus = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_NormalAttackDamageReduce(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.NormalAttackDamageReduce = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_NormalAttackDamageBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.NormalAttackDamageBonus = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_SkillDamageReduce(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.SkillDamageReduce = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_SkillDamageBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.SkillDamageBonus = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_Thorns(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.Thorns = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_selectable(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.selectable = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isDead(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isDead = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isDying(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isDying = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_searchInfos(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.searchInfos = (System.Collections.Generic.List<Gameplay.PVE.Data.UnitData.SearchInfo>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<Gameplay.PVE.Data.UnitData.SearchInfo>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_searchType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.searchType = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_unitType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.unitType = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_id(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.id = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_stage(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.stage = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_team(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.team = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_index(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.index = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_autoSkillPriority(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.autoSkillPriority = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_autoSkillCd(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.autoSkillCd = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_autoSkillBornCd(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.autoSkillBornCd = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hasAutoUsedSkill(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hasAutoUsedSkill = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_lockTarget(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.lockTarget = (Gameplay.PVE.Entity.UnitBase)translator.GetObject(L, 2, typeof(Gameplay.PVE.Entity.UnitBase));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hatredTarget(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hatredTarget = (Gameplay.PVE.Entity.BattleUnit)translator.GetObject(L, 2, typeof(Gameplay.PVE.Entity.BattleUnit));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_rigidRatio(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.rigidRatio = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hatredDistance(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hatredDistance = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_astarPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.astarPosition = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_moveOffset(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.moveOffset = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_moveForwardOffset(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.moveForwardOffset = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_moveStateChangeTime(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.moveStateChangeTime = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_manualAimForward(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.manualAimForward = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_damageForward(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.damageForward = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_birthPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.birthPosition = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_targetPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.targetPosition = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_targetForward(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.targetForward = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_patrolPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.patrolPosition = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_rendererOriginScale(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.rendererOriginScale = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_configAttackPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.configAttackPosition = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_attackRange(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.attackRange = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_searchRange(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.searchRange = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_moveSpeedRatio(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.moveSpeedRatio = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isSummonUnit(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isSummonUnit = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_summonId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.summonId = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_summonConfig(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.summonConfig = (Gameplay.PVE.Config.RpgSummonConfig)translator.GetObject(L, 2, typeof(Gameplay.PVE.Config.RpgSummonConfig));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_summonIndex(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.summonIndex = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_summonSkillIndex(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.summonSkillIndex = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_summonParent(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.summonParent = (Gameplay.PVE.Entity.UnitBase)translator.GetObject(L, 2, typeof(Gameplay.PVE.Entity.UnitBase));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_summonUnit(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.summonUnit = (Gameplay.PVE.Entity.UnitBase)translator.GetObject(L, 2, typeof(Gameplay.PVE.Entity.UnitBase));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_killNum(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.killNum = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_rangeType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.rangeType = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_positionType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.positionType = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isCanSquat(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isCanSquat = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_attackSpeedRatio(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.attackSpeedRatio = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_targetMoveSpeed(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.targetMoveSpeed = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_moveSpeedAccelerate(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.moveSpeedAccelerate = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_configMoveSpeed(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.configMoveSpeed = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_walkSpeed(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.walkSpeed = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_runSpeed(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.runSpeed = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_angleSpeed(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.angleSpeed = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isDraggable(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isDraggable = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_damageRatio(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.damageRatio = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isLogicPause(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isLogicPause = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hasBattleInSight(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hasBattleInSight = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hasObstacleFront(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hasObstacleFront = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_battleInSightPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.battleInSightPosition = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hatredDic(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hatredDic = (System.Collections.Generic.Dictionary<int, Gameplay.PVE.Data.HatredInfo>)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary<int, Gameplay.PVE.Data.HatredInfo>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_skillList(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.skillList = (System.Collections.Generic.List<int>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<int>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_bornElements(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.bornElements = (System.Collections.Generic.List<int>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<int>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_considerAstar(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.considerAstar = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_obstacleConfig(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.obstacleConfig = (Gameplay.PVE.Config.RpgObstacleConfig)translator.GetObject(L, 2, typeof(Gameplay.PVE.Config.RpgObstacleConfig));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_config(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.config = (Gameplay.PVE.Config.RpgModelConfig)translator.GetObject(L, 2, typeof(Gameplay.PVE.Config.RpgModelConfig));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_modelId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.modelId = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_deadModelId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.deadModelId = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_skillModelId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.skillModelId = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_rpgAttackRange(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.rpgAttackRange = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_pveAttackRange(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.pveAttackRange = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_rpgSkillCost(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.rpgSkillCost = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_shootTurns(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.shootTurns = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_ammoCount(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.ammoCount = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_shootInterval(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.shootInterval = (System.Collections.Generic.List<float>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<float>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_fixedShootInterval(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.fixedShootInterval = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_rpgNormalAttackId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.rpgNormalAttackId = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_rpgNormalSquatAttackId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.rpgNormalSquatAttackId = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_rpgMoveAttackId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.rpgMoveAttackId = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_rpgSkillId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.rpgSkillId = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_rpgSkillInitiativeLevel(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.rpgSkillInitiativeLevel = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_rpgPassiveSkillIds(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.rpgPassiveSkillIds = (System.Collections.Generic.Dictionary<int, int>)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary<int, int>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_rpgPassiveSkillPriority(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.rpgPassiveSkillPriority = (System.Collections.Generic.Dictionary<int, int>)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary<int, int>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_weaponType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.weaponType = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_walkSpeedRatio(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.walkSpeedRatio = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_runSpeedRatio(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.runSpeedRatio = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_searchTypeRpg(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.searchTypeRpg = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_searchTypePve(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.searchTypePve = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_searchSort(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.searchSort = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_searchChangeType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.searchChangeType = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_reloadTime(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.reloadTime = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_moveType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.moveType = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_rpgNormalAttackSkillConfig(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.rpgNormalAttackSkillConfig = (Gameplay.PVE.Config.PveSkillConfig)translator.GetObject(L, 2, typeof(Gameplay.PVE.Config.PveSkillConfig));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_rpgInitiativeSkillConfig(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.rpgInitiativeSkillConfig = (Gameplay.PVE.Config.PveSkillConfig)translator.GetObject(L, 2, typeof(Gameplay.PVE.Config.PveSkillConfig));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_rpgMoveAttackSkillConfig(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.rpgMoveAttackSkillConfig = (Gameplay.PVE.Config.PveSkillConfig)translator.GetObject(L, 2, typeof(Gameplay.PVE.Config.PveSkillConfig));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_enemyStage(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.enemyStage = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_enemyIndex(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.enemyIndex = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_colliderSize(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.colliderSize = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_colliderCenter(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.colliderCenter = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_skillCd(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.skillCd = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_lastSkillTime(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.lastSkillTime = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_bornTime(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.bornTime = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_followOffset(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.followOffset = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_followOffsetDistance(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.followOffsetDistance = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_followOffsetDistanceSqr(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.followOffsetDistanceSqr = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_followTarget(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.followTarget = (Gameplay.PVE.Entity.UnitBase)translator.GetObject(L, 2, typeof(Gameplay.PVE.Entity.UnitBase));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hasTriggerdSpecialCase(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hasTriggerdSpecialCase = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isInSpecialCase(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isInSpecialCase = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hitPoints(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hitPoints = (System.Collections.Generic.List<UnityEngine.Transform>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<UnityEngine.Transform>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_gunPoints(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.gunPoints = (System.Collections.Generic.List<UnityEngine.Transform>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<UnityEngine.Transform>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_bulletCasePoints(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.bulletCasePoints = (System.Collections.Generic.List<UnityEngine.Transform>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<UnityEngine.Transform>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_skillEffectPoints(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.skillEffectPoints = (System.Collections.Generic.List<UnityEngine.Transform>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<UnityEngine.Transform>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_buffEffectPoints(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.buffEffectPoints = (System.Collections.Generic.List<UnityEngine.Transform>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<UnityEngine.Transform>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_flyTextPoint(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.flyTextPoint = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_flyTextCriticalPoint(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.flyTextCriticalPoint = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_flyTextRange(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.flyTextRange = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hudPoint(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hudPoint = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hudHeight(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hudHeight = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isInBirthPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isInBirthPosition = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hasInitedRpg(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hasInitedRpg = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_leftAmmoCount(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.leftAmmoCount = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_totalAmmoCount(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.totalAmmoCount = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isReloading(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isReloading = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hidePositions(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hidePositions = (System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<UnityEngine.Vector3>>)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<UnityEngine.Vector3>>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hidingUnit(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hidingUnit = (Gameplay.PVE.Entity.UnitBase)translator.GetObject(L, 2, typeof(Gameplay.PVE.Entity.UnitBase));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_readyTohideObstacle(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.readyTohideObstacle = (Gameplay.PVE.Entity.ObstacleUnit)translator.GetObject(L, 2, typeof(Gameplay.PVE.Entity.ObstacleUnit));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hidingObstacle(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hidingObstacle = (Gameplay.PVE.Entity.ObstacleUnit)translator.GetObject(L, 2, typeof(Gameplay.PVE.Entity.ObstacleUnit));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hidePosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.hidePosition = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isInStageAttackPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isInStageAttackPosition = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_stageAttackPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.stageAttackPosition = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isBoss(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isBoss = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isElite(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isElite = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_canShowBossWarning(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.canShowBossWarning = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isShowingSpawn(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isShowingSpawn = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isGoingToHidePoint(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isGoingToHidePoint = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isManualMoving(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isManualMoving = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_needNextShoot(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.needNextShoot = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isMoveAttacking(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isMoveAttacking = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_ignoreAmmoLimit(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.ignoreAmmoLimit = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isApplyAnimationMovement(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isApplyAnimationMovement = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isDisarm(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isDisarm = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isSilent(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isSilent = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isInAction(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isInAction = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_battleUnit(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.battleUnit = (Gameplay.PVE.Entity.BattleUnit)translator.GetObject(L, 2, typeof(Gameplay.PVE.Entity.BattleUnit));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_targetHidingPoint(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.targetHidingPoint = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_accuracy(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.accuracy = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_evade(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.evade = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_bulletForward(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.bulletForward = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_aimTransform(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.aimTransform = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_aimTransformIndex(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.aimTransformIndex = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hasJoinBattle(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hasJoinBattle = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isCanMoveAttack(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isCanMoveAttack = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_switchWeaponId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.switchWeaponId = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_roadType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.roadType = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_lifeTime(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.lifeTime = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_heroId(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.heroId = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_monsterID(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.monsterID = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hasShowBossWarning(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hasShowBossWarning = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_monsterConfig(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.monsterConfig = (Gameplay.PVE.Config.RpgMonsterConfig)translator.GetObject(L, 2, typeof(Gameplay.PVE.Config.RpgMonsterConfig));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_attackSequenceSkills(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.attackSequenceSkills = (System.Collections.Generic.List<int>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<int>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_specialBuffs(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.specialBuffs = (System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<Gameplay.PVE.ElementBase>>)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<Gameplay.PVE.ElementBase>>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_normalAttackTimeEachTurn(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.normalAttackTimeEachTurn = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_mpCost(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.mpCost = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_GenderDamageBonus(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.GenderDamageBonus = (System.Collections.Generic.List<float>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<float>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_GenderDamageReduce(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.GenderDamageReduce = (System.Collections.Generic.List<float>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<float>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_Gender(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.Gender = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_controlable(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.controlable = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_invulnerableList(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.invulnerableList = (System.Collections.Generic.List<Gameplay.PVE.ElementBase>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<Gameplay.PVE.ElementBase>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_blockList(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.blockList = (System.Collections.Generic.List<UnityEngine.Vector2>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<UnityEngine.Vector2>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_tagList(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.tagList = (System.Collections.Generic.Dictionary<int, int>)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary<int, int>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_initAttack(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.initAttack = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_initDefence(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.initDefence = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_initMp(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.initMp = (float)LuaAPI.lua_tonumber(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isHiding(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isHiding = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_controlType(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                Gameplay.PVE.EControlType gen_value;translator.Get(L, 2, out gen_value);
				gen_to_be_invoked.controlType = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_attractAttackTarget(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.attractAttackTarget = (Gameplay.PVE.Entity.UnitBase)translator.GetObject(L, 2, typeof(Gameplay.PVE.Entity.UnitBase));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_hasReachAttackPosition(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.hasReachAttackPosition = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isCanAttackByFindPath(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isCanAttackByFindPath = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isSelfMeleeAtRegion(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isSelfMeleeAtRegion = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_firstTimeShowInScreen(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Gameplay.PVE.Data.UnitData gen_to_be_invoked = (Gameplay.PVE.Data.UnitData)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.firstTimeShowInScreen = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
		
		
		
		
    }
}
